package subassembly.fairlock;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 1. 公平锁和非公平锁的区别
 * 锁被释放的同时，后进来的线程来竞争锁，会判断队列中是否有其他线程等待，若存在，那么获取失败。
 *
 * 非公平锁效率高于公平锁的原因：
 * 因为非公平锁减少了线程挂起的几率，后来的线程有一定几率逃离被挂起的开销。
 */
public class Demo {

    /**
     * 实现上的区别是
     * 获取锁时候，判断获取锁的线程   ，是否是头节点的下一个节点，如果是那么获取成功，如果不是那么获取失败。
     *
     *     public final boolean hasQueuedPredecessors() {
     *         AbstractQueuedSynchronizer.Node h;
     *         if ((h = this.head) != null) {
     *             AbstractQueuedSynchronizer.Node s;
     *             if ((s = h.next) == null || s.waitStatus > 0) {
     *                 s = null;
     *
     *                 for(AbstractQueuedSynchronizer.Node p = this.tail; p != h && p != null; p = p.prev) {
     *                     if (p.waitStatus <= 0) {
     *                         s = p;
     *                     }
     *                 }
     *             }
     *
     *             if (s != null && s.thread != Thread.currentThread()) {
     *                 return true;
     *             }
     *         }
     *
     *         return false;
     *     }
     */
    public void demo(){

        ReentrantLock r = new ReentrantLock(false);
        ReentrantLock r2 = new ReentrantLock();
        r2.lock();
    }
}
